package com.zed.code.model;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class ChargesessionExample {
    protected String orderByClause;

    protected boolean distinct;

    protected List<Criteria> oredCriteria;

    public ChargesessionExample() {
        oredCriteria = new ArrayList<Criteria>();
    }

    public void setOrderByClause(String orderByClause) {
        this.orderByClause = orderByClause;
    }

    public String getOrderByClause() {
        return orderByClause;
    }

    public void setDistinct(boolean distinct) {
        this.distinct = distinct;
    }

    public boolean isDistinct() {
        return distinct;
    }

    public List<Criteria> getOredCriteria() {
        return oredCriteria;
    }

    public void or(Criteria criteria) {
        oredCriteria.add(criteria);
    }

    public Criteria or() {
        Criteria criteria = createCriteriaInternal();
        oredCriteria.add(criteria);
        return criteria;
    }

    public Criteria createCriteria() {
        Criteria criteria = createCriteriaInternal();
        if (oredCriteria.size() == 0) {
            oredCriteria.add(criteria);
        }
        return criteria;
    }

    protected Criteria createCriteriaInternal() {
        Criteria criteria = new Criteria();
        return criteria;
    }

    public void clear() {
        oredCriteria.clear();
        orderByClause = null;
        distinct = false;
    }

    protected abstract static class GeneratedCriteria {
        protected List<Criterion> criteria;

        protected GeneratedCriteria() {
            super();
            criteria = new ArrayList<Criterion>();
        }

        public boolean isValid() {
            return criteria.size() > 0;
        }

        public List<Criterion> getAllCriteria() {
            return criteria;
        }

        public List<Criterion> getCriteria() {
            return criteria;
        }

        protected void addCriterion(String condition) {
            if (condition == null) {
                throw new RuntimeException("Value for condition cannot be null");
            }
            criteria.add(new Criterion(condition));
        }

        protected void addCriterion(String condition, Object value, String property) {
            if (value == null) {
                throw new RuntimeException("Value for " + property + " cannot be null");
            }
            criteria.add(new Criterion(condition, value));
        }

        protected void addCriterion(String condition, Object value1, Object value2, String property) {
            if (value1 == null || value2 == null) {
                throw new RuntimeException("Between values for " + property + " cannot be null");
            }
            criteria.add(new Criterion(condition, value1, value2));
        }

        public Criteria andIdIsNull() {
            addCriterion("ID is null");
            return (Criteria) this;
        }

        public Criteria andIdIsNotNull() {
            addCriterion("ID is not null");
            return (Criteria) this;
        }

        public Criteria andIdEqualTo(Integer value) {
            addCriterion("ID =", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdNotEqualTo(Integer value) {
            addCriterion("ID <>", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdGreaterThan(Integer value) {
            addCriterion("ID >", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdGreaterThanOrEqualTo(Integer value) {
            addCriterion("ID >=", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdLessThan(Integer value) {
            addCriterion("ID <", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdLessThanOrEqualTo(Integer value) {
            addCriterion("ID <=", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdIn(List<Integer> values) {
            addCriterion("ID in", values, "id");
            return (Criteria) this;
        }

        public Criteria andIdNotIn(List<Integer> values) {
            addCriterion("ID not in", values, "id");
            return (Criteria) this;
        }

        public Criteria andIdBetween(Integer value1, Integer value2) {
            addCriterion("ID between", value1, value2, "id");
            return (Criteria) this;
        }

        public Criteria andIdNotBetween(Integer value1, Integer value2) {
            addCriterion("ID not between", value1, value2, "id");
            return (Criteria) this;
        }

        public Criteria andSessionidIsNull() {
            addCriterion("SessionId is null");
            return (Criteria) this;
        }

        public Criteria andSessionidIsNotNull() {
            addCriterion("SessionId is not null");
            return (Criteria) this;
        }

        public Criteria andSessionidEqualTo(String value) {
            addCriterion("SessionId =", value, "sessionid");
            return (Criteria) this;
        }

        public Criteria andSessionidNotEqualTo(String value) {
            addCriterion("SessionId <>", value, "sessionid");
            return (Criteria) this;
        }

        public Criteria andSessionidGreaterThan(String value) {
            addCriterion("SessionId >", value, "sessionid");
            return (Criteria) this;
        }

        public Criteria andSessionidGreaterThanOrEqualTo(String value) {
            addCriterion("SessionId >=", value, "sessionid");
            return (Criteria) this;
        }

        public Criteria andSessionidLessThan(String value) {
            addCriterion("SessionId <", value, "sessionid");
            return (Criteria) this;
        }

        public Criteria andSessionidLessThanOrEqualTo(String value) {
            addCriterion("SessionId <=", value, "sessionid");
            return (Criteria) this;
        }

        public Criteria andSessionidLike(String value) {
            addCriterion("SessionId like", value, "sessionid");
            return (Criteria) this;
        }

        public Criteria andSessionidNotLike(String value) {
            addCriterion("SessionId not like", value, "sessionid");
            return (Criteria) this;
        }

        public Criteria andSessionidIn(List<String> values) {
            addCriterion("SessionId in", values, "sessionid");
            return (Criteria) this;
        }

        public Criteria andSessionidNotIn(List<String> values) {
            addCriterion("SessionId not in", values, "sessionid");
            return (Criteria) this;
        }

        public Criteria andSessionidBetween(String value1, String value2) {
            addCriterion("SessionId between", value1, value2, "sessionid");
            return (Criteria) this;
        }

        public Criteria andSessionidNotBetween(String value1, String value2) {
            addCriterion("SessionId not between", value1, value2, "sessionid");
            return (Criteria) this;
        }

        public Criteria andNicknameIsNull() {
            addCriterion("NickName is null");
            return (Criteria) this;
        }

        public Criteria andNicknameIsNotNull() {
            addCriterion("NickName is not null");
            return (Criteria) this;
        }

        public Criteria andNicknameEqualTo(String value) {
            addCriterion("NickName =", value, "nickname");
            return (Criteria) this;
        }

        public Criteria andNicknameNotEqualTo(String value) {
            addCriterion("NickName <>", value, "nickname");
            return (Criteria) this;
        }

        public Criteria andNicknameGreaterThan(String value) {
            addCriterion("NickName >", value, "nickname");
            return (Criteria) this;
        }

        public Criteria andNicknameGreaterThanOrEqualTo(String value) {
            addCriterion("NickName >=", value, "nickname");
            return (Criteria) this;
        }

        public Criteria andNicknameLessThan(String value) {
            addCriterion("NickName <", value, "nickname");
            return (Criteria) this;
        }

        public Criteria andNicknameLessThanOrEqualTo(String value) {
            addCriterion("NickName <=", value, "nickname");
            return (Criteria) this;
        }

        public Criteria andNicknameLike(String value) {
            addCriterion("NickName like", value, "nickname");
            return (Criteria) this;
        }

        public Criteria andNicknameNotLike(String value) {
            addCriterion("NickName not like", value, "nickname");
            return (Criteria) this;
        }

        public Criteria andNicknameIn(List<String> values) {
            addCriterion("NickName in", values, "nickname");
            return (Criteria) this;
        }

        public Criteria andNicknameNotIn(List<String> values) {
            addCriterion("NickName not in", values, "nickname");
            return (Criteria) this;
        }

        public Criteria andNicknameBetween(String value1, String value2) {
            addCriterion("NickName between", value1, value2, "nickname");
            return (Criteria) this;
        }

        public Criteria andNicknameNotBetween(String value1, String value2) {
            addCriterion("NickName not between", value1, value2, "nickname");
            return (Criteria) this;
        }

        public Criteria andOpenidIsNull() {
            addCriterion("OpenId is null");
            return (Criteria) this;
        }

        public Criteria andOpenidIsNotNull() {
            addCriterion("OpenId is not null");
            return (Criteria) this;
        }

        public Criteria andOpenidEqualTo(String value) {
            addCriterion("OpenId =", value, "openid");
            return (Criteria) this;
        }

        public Criteria andOpenidNotEqualTo(String value) {
            addCriterion("OpenId <>", value, "openid");
            return (Criteria) this;
        }

        public Criteria andOpenidGreaterThan(String value) {
            addCriterion("OpenId >", value, "openid");
            return (Criteria) this;
        }

        public Criteria andOpenidGreaterThanOrEqualTo(String value) {
            addCriterion("OpenId >=", value, "openid");
            return (Criteria) this;
        }

        public Criteria andOpenidLessThan(String value) {
            addCriterion("OpenId <", value, "openid");
            return (Criteria) this;
        }

        public Criteria andOpenidLessThanOrEqualTo(String value) {
            addCriterion("OpenId <=", value, "openid");
            return (Criteria) this;
        }

        public Criteria andOpenidLike(String value) {
            addCriterion("OpenId like", value, "openid");
            return (Criteria) this;
        }

        public Criteria andOpenidNotLike(String value) {
            addCriterion("OpenId not like", value, "openid");
            return (Criteria) this;
        }

        public Criteria andOpenidIn(List<String> values) {
            addCriterion("OpenId in", values, "openid");
            return (Criteria) this;
        }

        public Criteria andOpenidNotIn(List<String> values) {
            addCriterion("OpenId not in", values, "openid");
            return (Criteria) this;
        }

        public Criteria andOpenidBetween(String value1, String value2) {
            addCriterion("OpenId between", value1, value2, "openid");
            return (Criteria) this;
        }

        public Criteria andOpenidNotBetween(String value1, String value2) {
            addCriterion("OpenId not between", value1, value2, "openid");
            return (Criteria) this;
        }

        public Criteria andStationidIsNull() {
            addCriterion("StationId is null");
            return (Criteria) this;
        }

        public Criteria andStationidIsNotNull() {
            addCriterion("StationId is not null");
            return (Criteria) this;
        }

        public Criteria andStationidEqualTo(Integer value) {
            addCriterion("StationId =", value, "stationid");
            return (Criteria) this;
        }

        public Criteria andStationidNotEqualTo(Integer value) {
            addCriterion("StationId <>", value, "stationid");
            return (Criteria) this;
        }

        public Criteria andStationidGreaterThan(Integer value) {
            addCriterion("StationId >", value, "stationid");
            return (Criteria) this;
        }

        public Criteria andStationidGreaterThanOrEqualTo(Integer value) {
            addCriterion("StationId >=", value, "stationid");
            return (Criteria) this;
        }

        public Criteria andStationidLessThan(Integer value) {
            addCriterion("StationId <", value, "stationid");
            return (Criteria) this;
        }

        public Criteria andStationidLessThanOrEqualTo(Integer value) {
            addCriterion("StationId <=", value, "stationid");
            return (Criteria) this;
        }

        public Criteria andStationidIn(List<Integer> values) {
            addCriterion("StationId in", values, "stationid");
            return (Criteria) this;
        }

        public Criteria andStationidNotIn(List<Integer> values) {
            addCriterion("StationId not in", values, "stationid");
            return (Criteria) this;
        }

        public Criteria andStationidBetween(Integer value1, Integer value2) {
            addCriterion("StationId between", value1, value2, "stationid");
            return (Criteria) this;
        }

        public Criteria andStationidNotBetween(Integer value1, Integer value2) {
            addCriterion("StationId not between", value1, value2, "stationid");
            return (Criteria) this;
        }

        public Criteria andStationnameIsNull() {
            addCriterion("StationName is null");
            return (Criteria) this;
        }

        public Criteria andStationnameIsNotNull() {
            addCriterion("StationName is not null");
            return (Criteria) this;
        }

        public Criteria andStationnameEqualTo(String value) {
            addCriterion("StationName =", value, "stationname");
            return (Criteria) this;
        }

        public Criteria andStationnameNotEqualTo(String value) {
            addCriterion("StationName <>", value, "stationname");
            return (Criteria) this;
        }

        public Criteria andStationnameGreaterThan(String value) {
            addCriterion("StationName >", value, "stationname");
            return (Criteria) this;
        }

        public Criteria andStationnameGreaterThanOrEqualTo(String value) {
            addCriterion("StationName >=", value, "stationname");
            return (Criteria) this;
        }

        public Criteria andStationnameLessThan(String value) {
            addCriterion("StationName <", value, "stationname");
            return (Criteria) this;
        }

        public Criteria andStationnameLessThanOrEqualTo(String value) {
            addCriterion("StationName <=", value, "stationname");
            return (Criteria) this;
        }

        public Criteria andStationnameLike(String value) {
            addCriterion("StationName like", value, "stationname");
            return (Criteria) this;
        }

        public Criteria andStationnameNotLike(String value) {
            addCriterion("StationName not like", value, "stationname");
            return (Criteria) this;
        }

        public Criteria andStationnameIn(List<String> values) {
            addCriterion("StationName in", values, "stationname");
            return (Criteria) this;
        }

        public Criteria andStationnameNotIn(List<String> values) {
            addCriterion("StationName not in", values, "stationname");
            return (Criteria) this;
        }

        public Criteria andStationnameBetween(String value1, String value2) {
            addCriterion("StationName between", value1, value2, "stationname");
            return (Criteria) this;
        }

        public Criteria andStationnameNotBetween(String value1, String value2) {
            addCriterion("StationName not between", value1, value2, "stationname");
            return (Criteria) this;
        }

        public Criteria andDeviceidIsNull() {
            addCriterion("DeviceId is null");
            return (Criteria) this;
        }

        public Criteria andDeviceidIsNotNull() {
            addCriterion("DeviceId is not null");
            return (Criteria) this;
        }

        public Criteria andDeviceidEqualTo(String value) {
            addCriterion("DeviceId =", value, "deviceid");
            return (Criteria) this;
        }

        public Criteria andDeviceidNotEqualTo(String value) {
            addCriterion("DeviceId <>", value, "deviceid");
            return (Criteria) this;
        }

        public Criteria andDeviceidGreaterThan(String value) {
            addCriterion("DeviceId >", value, "deviceid");
            return (Criteria) this;
        }

        public Criteria andDeviceidGreaterThanOrEqualTo(String value) {
            addCriterion("DeviceId >=", value, "deviceid");
            return (Criteria) this;
        }

        public Criteria andDeviceidLessThan(String value) {
            addCriterion("DeviceId <", value, "deviceid");
            return (Criteria) this;
        }

        public Criteria andDeviceidLessThanOrEqualTo(String value) {
            addCriterion("DeviceId <=", value, "deviceid");
            return (Criteria) this;
        }

        public Criteria andDeviceidLike(String value) {
            addCriterion("DeviceId like", value, "deviceid");
            return (Criteria) this;
        }

        public Criteria andDeviceidNotLike(String value) {
            addCriterion("DeviceId not like", value, "deviceid");
            return (Criteria) this;
        }

        public Criteria andDeviceidIn(List<String> values) {
            addCriterion("DeviceId in", values, "deviceid");
            return (Criteria) this;
        }

        public Criteria andDeviceidNotIn(List<String> values) {
            addCriterion("DeviceId not in", values, "deviceid");
            return (Criteria) this;
        }

        public Criteria andDeviceidBetween(String value1, String value2) {
            addCriterion("DeviceId between", value1, value2, "deviceid");
            return (Criteria) this;
        }

        public Criteria andDeviceidNotBetween(String value1, String value2) {
            addCriterion("DeviceId not between", value1, value2, "deviceid");
            return (Criteria) this;
        }

        public Criteria andPortIsNull() {
            addCriterion("Port is null");
            return (Criteria) this;
        }

        public Criteria andPortIsNotNull() {
            addCriterion("Port is not null");
            return (Criteria) this;
        }

        public Criteria andPortEqualTo(Byte value) {
            addCriterion("Port =", value, "port");
            return (Criteria) this;
        }

        public Criteria andPortNotEqualTo(Byte value) {
            addCriterion("Port <>", value, "port");
            return (Criteria) this;
        }

        public Criteria andPortGreaterThan(Byte value) {
            addCriterion("Port >", value, "port");
            return (Criteria) this;
        }

        public Criteria andPortGreaterThanOrEqualTo(Byte value) {
            addCriterion("Port >=", value, "port");
            return (Criteria) this;
        }

        public Criteria andPortLessThan(Byte value) {
            addCriterion("Port <", value, "port");
            return (Criteria) this;
        }

        public Criteria andPortLessThanOrEqualTo(Byte value) {
            addCriterion("Port <=", value, "port");
            return (Criteria) this;
        }

        public Criteria andPortIn(List<Byte> values) {
            addCriterion("Port in", values, "port");
            return (Criteria) this;
        }

        public Criteria andPortNotIn(List<Byte> values) {
            addCriterion("Port not in", values, "port");
            return (Criteria) this;
        }

        public Criteria andPortBetween(Byte value1, Byte value2) {
            addCriterion("Port between", value1, value2, "port");
            return (Criteria) this;
        }

        public Criteria andPortNotBetween(Byte value1, Byte value2) {
            addCriterion("Port not between", value1, value2, "port");
            return (Criteria) this;
        }

        public Criteria andVoltageIsNull() {
            addCriterion("Voltage is null");
            return (Criteria) this;
        }

        public Criteria andVoltageIsNotNull() {
            addCriterion("Voltage is not null");
            return (Criteria) this;
        }

        public Criteria andVoltageEqualTo(BigDecimal value) {
            addCriterion("Voltage =", value, "voltage");
            return (Criteria) this;
        }

        public Criteria andVoltageNotEqualTo(BigDecimal value) {
            addCriterion("Voltage <>", value, "voltage");
            return (Criteria) this;
        }

        public Criteria andVoltageGreaterThan(BigDecimal value) {
            addCriterion("Voltage >", value, "voltage");
            return (Criteria) this;
        }

        public Criteria andVoltageGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("Voltage >=", value, "voltage");
            return (Criteria) this;
        }

        public Criteria andVoltageLessThan(BigDecimal value) {
            addCriterion("Voltage <", value, "voltage");
            return (Criteria) this;
        }

        public Criteria andVoltageLessThanOrEqualTo(BigDecimal value) {
            addCriterion("Voltage <=", value, "voltage");
            return (Criteria) this;
        }

        public Criteria andVoltageIn(List<BigDecimal> values) {
            addCriterion("Voltage in", values, "voltage");
            return (Criteria) this;
        }

        public Criteria andVoltageNotIn(List<BigDecimal> values) {
            addCriterion("Voltage not in", values, "voltage");
            return (Criteria) this;
        }

        public Criteria andVoltageBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("Voltage between", value1, value2, "voltage");
            return (Criteria) this;
        }

        public Criteria andVoltageNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("Voltage not between", value1, value2, "voltage");
            return (Criteria) this;
        }

        public Criteria andCurrentIsNull() {
            addCriterion("`Current` is null");
            return (Criteria) this;
        }

        public Criteria andCurrentIsNotNull() {
            addCriterion("`Current` is not null");
            return (Criteria) this;
        }

        public Criteria andCurrentEqualTo(BigDecimal value) {
            addCriterion("`Current` =", value, "current");
            return (Criteria) this;
        }

        public Criteria andCurrentNotEqualTo(BigDecimal value) {
            addCriterion("`Current` <>", value, "current");
            return (Criteria) this;
        }

        public Criteria andCurrentGreaterThan(BigDecimal value) {
            addCriterion("`Current` >", value, "current");
            return (Criteria) this;
        }

        public Criteria andCurrentGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("`Current` >=", value, "current");
            return (Criteria) this;
        }

        public Criteria andCurrentLessThan(BigDecimal value) {
            addCriterion("`Current` <", value, "current");
            return (Criteria) this;
        }

        public Criteria andCurrentLessThanOrEqualTo(BigDecimal value) {
            addCriterion("`Current` <=", value, "current");
            return (Criteria) this;
        }

        public Criteria andCurrentIn(List<BigDecimal> values) {
            addCriterion("`Current` in", values, "current");
            return (Criteria) this;
        }

        public Criteria andCurrentNotIn(List<BigDecimal> values) {
            addCriterion("`Current` not in", values, "current");
            return (Criteria) this;
        }

        public Criteria andCurrentBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("`Current` between", value1, value2, "current");
            return (Criteria) this;
        }

        public Criteria andCurrentNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("`Current` not between", value1, value2, "current");
            return (Criteria) this;
        }

        public Criteria andAmountchargedIsNull() {
            addCriterion("AmountCharged is null");
            return (Criteria) this;
        }

        public Criteria andAmountchargedIsNotNull() {
            addCriterion("AmountCharged is not null");
            return (Criteria) this;
        }

        public Criteria andAmountchargedEqualTo(BigDecimal value) {
            addCriterion("AmountCharged =", value, "amountcharged");
            return (Criteria) this;
        }

        public Criteria andAmountchargedNotEqualTo(BigDecimal value) {
            addCriterion("AmountCharged <>", value, "amountcharged");
            return (Criteria) this;
        }

        public Criteria andAmountchargedGreaterThan(BigDecimal value) {
            addCriterion("AmountCharged >", value, "amountcharged");
            return (Criteria) this;
        }

        public Criteria andAmountchargedGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("AmountCharged >=", value, "amountcharged");
            return (Criteria) this;
        }

        public Criteria andAmountchargedLessThan(BigDecimal value) {
            addCriterion("AmountCharged <", value, "amountcharged");
            return (Criteria) this;
        }

        public Criteria andAmountchargedLessThanOrEqualTo(BigDecimal value) {
            addCriterion("AmountCharged <=", value, "amountcharged");
            return (Criteria) this;
        }

        public Criteria andAmountchargedIn(List<BigDecimal> values) {
            addCriterion("AmountCharged in", values, "amountcharged");
            return (Criteria) this;
        }

        public Criteria andAmountchargedNotIn(List<BigDecimal> values) {
            addCriterion("AmountCharged not in", values, "amountcharged");
            return (Criteria) this;
        }

        public Criteria andAmountchargedBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("AmountCharged between", value1, value2, "amountcharged");
            return (Criteria) this;
        }

        public Criteria andAmountchargedNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("AmountCharged not between", value1, value2, "amountcharged");
            return (Criteria) this;
        }

        public Criteria andTimechargedIsNull() {
            addCriterion("TimeCharged is null");
            return (Criteria) this;
        }

        public Criteria andTimechargedIsNotNull() {
            addCriterion("TimeCharged is not null");
            return (Criteria) this;
        }

        public Criteria andTimechargedEqualTo(BigDecimal value) {
            addCriterion("TimeCharged =", value, "timecharged");
            return (Criteria) this;
        }

        public Criteria andTimechargedNotEqualTo(BigDecimal value) {
            addCriterion("TimeCharged <>", value, "timecharged");
            return (Criteria) this;
        }

        public Criteria andTimechargedGreaterThan(BigDecimal value) {
            addCriterion("TimeCharged >", value, "timecharged");
            return (Criteria) this;
        }

        public Criteria andTimechargedGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("TimeCharged >=", value, "timecharged");
            return (Criteria) this;
        }

        public Criteria andTimechargedLessThan(BigDecimal value) {
            addCriterion("TimeCharged <", value, "timecharged");
            return (Criteria) this;
        }

        public Criteria andTimechargedLessThanOrEqualTo(BigDecimal value) {
            addCriterion("TimeCharged <=", value, "timecharged");
            return (Criteria) this;
        }

        public Criteria andTimechargedIn(List<BigDecimal> values) {
            addCriterion("TimeCharged in", values, "timecharged");
            return (Criteria) this;
        }

        public Criteria andTimechargedNotIn(List<BigDecimal> values) {
            addCriterion("TimeCharged not in", values, "timecharged");
            return (Criteria) this;
        }

        public Criteria andTimechargedBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("TimeCharged between", value1, value2, "timecharged");
            return (Criteria) this;
        }

        public Criteria andTimechargedNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("TimeCharged not between", value1, value2, "timecharged");
            return (Criteria) this;
        }

        public Criteria andAmountIsNull() {
            addCriterion("Amount is null");
            return (Criteria) this;
        }

        public Criteria andAmountIsNotNull() {
            addCriterion("Amount is not null");
            return (Criteria) this;
        }

        public Criteria andAmountEqualTo(BigDecimal value) {
            addCriterion("Amount =", value, "amount");
            return (Criteria) this;
        }

        public Criteria andAmountNotEqualTo(BigDecimal value) {
            addCriterion("Amount <>", value, "amount");
            return (Criteria) this;
        }

        public Criteria andAmountGreaterThan(BigDecimal value) {
            addCriterion("Amount >", value, "amount");
            return (Criteria) this;
        }

        public Criteria andAmountGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("Amount >=", value, "amount");
            return (Criteria) this;
        }

        public Criteria andAmountLessThan(BigDecimal value) {
            addCriterion("Amount <", value, "amount");
            return (Criteria) this;
        }

        public Criteria andAmountLessThanOrEqualTo(BigDecimal value) {
            addCriterion("Amount <=", value, "amount");
            return (Criteria) this;
        }

        public Criteria andAmountIn(List<BigDecimal> values) {
            addCriterion("Amount in", values, "amount");
            return (Criteria) this;
        }

        public Criteria andAmountNotIn(List<BigDecimal> values) {
            addCriterion("Amount not in", values, "amount");
            return (Criteria) this;
        }

        public Criteria andAmountBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("Amount between", value1, value2, "amount");
            return (Criteria) this;
        }

        public Criteria andAmountNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("Amount not between", value1, value2, "amount");
            return (Criteria) this;
        }

        public Criteria andPercentIsNull() {
            addCriterion("`Percent` is null");
            return (Criteria) this;
        }

        public Criteria andPercentIsNotNull() {
            addCriterion("`Percent` is not null");
            return (Criteria) this;
        }

        public Criteria andPercentEqualTo(BigDecimal value) {
            addCriterion("`Percent` =", value, "percent");
            return (Criteria) this;
        }

        public Criteria andPercentNotEqualTo(BigDecimal value) {
            addCriterion("`Percent` <>", value, "percent");
            return (Criteria) this;
        }

        public Criteria andPercentGreaterThan(BigDecimal value) {
            addCriterion("`Percent` >", value, "percent");
            return (Criteria) this;
        }

        public Criteria andPercentGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("`Percent` >=", value, "percent");
            return (Criteria) this;
        }

        public Criteria andPercentLessThan(BigDecimal value) {
            addCriterion("`Percent` <", value, "percent");
            return (Criteria) this;
        }

        public Criteria andPercentLessThanOrEqualTo(BigDecimal value) {
            addCriterion("`Percent` <=", value, "percent");
            return (Criteria) this;
        }

        public Criteria andPercentIn(List<BigDecimal> values) {
            addCriterion("`Percent` in", values, "percent");
            return (Criteria) this;
        }

        public Criteria andPercentNotIn(List<BigDecimal> values) {
            addCriterion("`Percent` not in", values, "percent");
            return (Criteria) this;
        }

        public Criteria andPercentBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("`Percent` between", value1, value2, "percent");
            return (Criteria) this;
        }

        public Criteria andPercentNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("`Percent` not between", value1, value2, "percent");
            return (Criteria) this;
        }

        public Criteria andBatterytypeIsNull() {
            addCriterion("BatteryType is null");
            return (Criteria) this;
        }

        public Criteria andBatterytypeIsNotNull() {
            addCriterion("BatteryType is not null");
            return (Criteria) this;
        }

        public Criteria andBatterytypeEqualTo(Integer value) {
            addCriterion("BatteryType =", value, "batterytype");
            return (Criteria) this;
        }

        public Criteria andBatterytypeNotEqualTo(Integer value) {
            addCriterion("BatteryType <>", value, "batterytype");
            return (Criteria) this;
        }

        public Criteria andBatterytypeGreaterThan(Integer value) {
            addCriterion("BatteryType >", value, "batterytype");
            return (Criteria) this;
        }

        public Criteria andBatterytypeGreaterThanOrEqualTo(Integer value) {
            addCriterion("BatteryType >=", value, "batterytype");
            return (Criteria) this;
        }

        public Criteria andBatterytypeLessThan(Integer value) {
            addCriterion("BatteryType <", value, "batterytype");
            return (Criteria) this;
        }

        public Criteria andBatterytypeLessThanOrEqualTo(Integer value) {
            addCriterion("BatteryType <=", value, "batterytype");
            return (Criteria) this;
        }

        public Criteria andBatterytypeIn(List<Integer> values) {
            addCriterion("BatteryType in", values, "batterytype");
            return (Criteria) this;
        }

        public Criteria andBatterytypeNotIn(List<Integer> values) {
            addCriterion("BatteryType not in", values, "batterytype");
            return (Criteria) this;
        }

        public Criteria andBatterytypeBetween(Integer value1, Integer value2) {
            addCriterion("BatteryType between", value1, value2, "batterytype");
            return (Criteria) this;
        }

        public Criteria andBatterytypeNotBetween(Integer value1, Integer value2) {
            addCriterion("BatteryType not between", value1, value2, "batterytype");
            return (Criteria) this;
        }

        public Criteria andAllpowerIsNull() {
            addCriterion("AllPower is null");
            return (Criteria) this;
        }

        public Criteria andAllpowerIsNotNull() {
            addCriterion("AllPower is not null");
            return (Criteria) this;
        }

        public Criteria andAllpowerEqualTo(BigDecimal value) {
            addCriterion("AllPower =", value, "allpower");
            return (Criteria) this;
        }

        public Criteria andAllpowerNotEqualTo(BigDecimal value) {
            addCriterion("AllPower <>", value, "allpower");
            return (Criteria) this;
        }

        public Criteria andAllpowerGreaterThan(BigDecimal value) {
            addCriterion("AllPower >", value, "allpower");
            return (Criteria) this;
        }

        public Criteria andAllpowerGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("AllPower >=", value, "allpower");
            return (Criteria) this;
        }

        public Criteria andAllpowerLessThan(BigDecimal value) {
            addCriterion("AllPower <", value, "allpower");
            return (Criteria) this;
        }

        public Criteria andAllpowerLessThanOrEqualTo(BigDecimal value) {
            addCriterion("AllPower <=", value, "allpower");
            return (Criteria) this;
        }

        public Criteria andAllpowerIn(List<BigDecimal> values) {
            addCriterion("AllPower in", values, "allpower");
            return (Criteria) this;
        }

        public Criteria andAllpowerNotIn(List<BigDecimal> values) {
            addCriterion("AllPower not in", values, "allpower");
            return (Criteria) this;
        }

        public Criteria andAllpowerBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("AllPower between", value1, value2, "allpower");
            return (Criteria) this;
        }

        public Criteria andAllpowerNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("AllPower not between", value1, value2, "allpower");
            return (Criteria) this;
        }

        public Criteria andCapacityIsNull() {
            addCriterion("Capacity is null");
            return (Criteria) this;
        }

        public Criteria andCapacityIsNotNull() {
            addCriterion("Capacity is not null");
            return (Criteria) this;
        }

        public Criteria andCapacityEqualTo(BigDecimal value) {
            addCriterion("Capacity =", value, "capacity");
            return (Criteria) this;
        }

        public Criteria andCapacityNotEqualTo(BigDecimal value) {
            addCriterion("Capacity <>", value, "capacity");
            return (Criteria) this;
        }

        public Criteria andCapacityGreaterThan(BigDecimal value) {
            addCriterion("Capacity >", value, "capacity");
            return (Criteria) this;
        }

        public Criteria andCapacityGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("Capacity >=", value, "capacity");
            return (Criteria) this;
        }

        public Criteria andCapacityLessThan(BigDecimal value) {
            addCriterion("Capacity <", value, "capacity");
            return (Criteria) this;
        }

        public Criteria andCapacityLessThanOrEqualTo(BigDecimal value) {
            addCriterion("Capacity <=", value, "capacity");
            return (Criteria) this;
        }

        public Criteria andCapacityIn(List<BigDecimal> values) {
            addCriterion("Capacity in", values, "capacity");
            return (Criteria) this;
        }

        public Criteria andCapacityNotIn(List<BigDecimal> values) {
            addCriterion("Capacity not in", values, "capacity");
            return (Criteria) this;
        }

        public Criteria andCapacityBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("Capacity between", value1, value2, "capacity");
            return (Criteria) this;
        }

        public Criteria andCapacityNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("Capacity not between", value1, value2, "capacity");
            return (Criteria) this;
        }

        public Criteria andMaxallowvoltageIsNull() {
            addCriterion("MaxAllowVoltage is null");
            return (Criteria) this;
        }

        public Criteria andMaxallowvoltageIsNotNull() {
            addCriterion("MaxAllowVoltage is not null");
            return (Criteria) this;
        }

        public Criteria andMaxallowvoltageEqualTo(BigDecimal value) {
            addCriterion("MaxAllowVoltage =", value, "maxallowvoltage");
            return (Criteria) this;
        }

        public Criteria andMaxallowvoltageNotEqualTo(BigDecimal value) {
            addCriterion("MaxAllowVoltage <>", value, "maxallowvoltage");
            return (Criteria) this;
        }

        public Criteria andMaxallowvoltageGreaterThan(BigDecimal value) {
            addCriterion("MaxAllowVoltage >", value, "maxallowvoltage");
            return (Criteria) this;
        }

        public Criteria andMaxallowvoltageGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("MaxAllowVoltage >=", value, "maxallowvoltage");
            return (Criteria) this;
        }

        public Criteria andMaxallowvoltageLessThan(BigDecimal value) {
            addCriterion("MaxAllowVoltage <", value, "maxallowvoltage");
            return (Criteria) this;
        }

        public Criteria andMaxallowvoltageLessThanOrEqualTo(BigDecimal value) {
            addCriterion("MaxAllowVoltage <=", value, "maxallowvoltage");
            return (Criteria) this;
        }

        public Criteria andMaxallowvoltageIn(List<BigDecimal> values) {
            addCriterion("MaxAllowVoltage in", values, "maxallowvoltage");
            return (Criteria) this;
        }

        public Criteria andMaxallowvoltageNotIn(List<BigDecimal> values) {
            addCriterion("MaxAllowVoltage not in", values, "maxallowvoltage");
            return (Criteria) this;
        }

        public Criteria andMaxallowvoltageBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("MaxAllowVoltage between", value1, value2, "maxallowvoltage");
            return (Criteria) this;
        }

        public Criteria andMaxallowvoltageNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("MaxAllowVoltage not between", value1, value2, "maxallowvoltage");
            return (Criteria) this;
        }

        public Criteria andMaxallowcurrentIsNull() {
            addCriterion("MaxAllowCurrent is null");
            return (Criteria) this;
        }

        public Criteria andMaxallowcurrentIsNotNull() {
            addCriterion("MaxAllowCurrent is not null");
            return (Criteria) this;
        }

        public Criteria andMaxallowcurrentEqualTo(BigDecimal value) {
            addCriterion("MaxAllowCurrent =", value, "maxallowcurrent");
            return (Criteria) this;
        }

        public Criteria andMaxallowcurrentNotEqualTo(BigDecimal value) {
            addCriterion("MaxAllowCurrent <>", value, "maxallowcurrent");
            return (Criteria) this;
        }

        public Criteria andMaxallowcurrentGreaterThan(BigDecimal value) {
            addCriterion("MaxAllowCurrent >", value, "maxallowcurrent");
            return (Criteria) this;
        }

        public Criteria andMaxallowcurrentGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("MaxAllowCurrent >=", value, "maxallowcurrent");
            return (Criteria) this;
        }

        public Criteria andMaxallowcurrentLessThan(BigDecimal value) {
            addCriterion("MaxAllowCurrent <", value, "maxallowcurrent");
            return (Criteria) this;
        }

        public Criteria andMaxallowcurrentLessThanOrEqualTo(BigDecimal value) {
            addCriterion("MaxAllowCurrent <=", value, "maxallowcurrent");
            return (Criteria) this;
        }

        public Criteria andMaxallowcurrentIn(List<BigDecimal> values) {
            addCriterion("MaxAllowCurrent in", values, "maxallowcurrent");
            return (Criteria) this;
        }

        public Criteria andMaxallowcurrentNotIn(List<BigDecimal> values) {
            addCriterion("MaxAllowCurrent not in", values, "maxallowcurrent");
            return (Criteria) this;
        }

        public Criteria andMaxallowcurrentBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("MaxAllowCurrent between", value1, value2, "maxallowcurrent");
            return (Criteria) this;
        }

        public Criteria andMaxallowcurrentNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("MaxAllowCurrent not between", value1, value2, "maxallowcurrent");
            return (Criteria) this;
        }

        public Criteria andSinglemaxallowvoltageIsNull() {
            addCriterion("SingleMaxAllowVoltage is null");
            return (Criteria) this;
        }

        public Criteria andSinglemaxallowvoltageIsNotNull() {
            addCriterion("SingleMaxAllowVoltage is not null");
            return (Criteria) this;
        }

        public Criteria andSinglemaxallowvoltageEqualTo(BigDecimal value) {
            addCriterion("SingleMaxAllowVoltage =", value, "singlemaxallowvoltage");
            return (Criteria) this;
        }

        public Criteria andSinglemaxallowvoltageNotEqualTo(BigDecimal value) {
            addCriterion("SingleMaxAllowVoltage <>", value, "singlemaxallowvoltage");
            return (Criteria) this;
        }

        public Criteria andSinglemaxallowvoltageGreaterThan(BigDecimal value) {
            addCriterion("SingleMaxAllowVoltage >", value, "singlemaxallowvoltage");
            return (Criteria) this;
        }

        public Criteria andSinglemaxallowvoltageGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("SingleMaxAllowVoltage >=", value, "singlemaxallowvoltage");
            return (Criteria) this;
        }

        public Criteria andSinglemaxallowvoltageLessThan(BigDecimal value) {
            addCriterion("SingleMaxAllowVoltage <", value, "singlemaxallowvoltage");
            return (Criteria) this;
        }

        public Criteria andSinglemaxallowvoltageLessThanOrEqualTo(BigDecimal value) {
            addCriterion("SingleMaxAllowVoltage <=", value, "singlemaxallowvoltage");
            return (Criteria) this;
        }

        public Criteria andSinglemaxallowvoltageIn(List<BigDecimal> values) {
            addCriterion("SingleMaxAllowVoltage in", values, "singlemaxallowvoltage");
            return (Criteria) this;
        }

        public Criteria andSinglemaxallowvoltageNotIn(List<BigDecimal> values) {
            addCriterion("SingleMaxAllowVoltage not in", values, "singlemaxallowvoltage");
            return (Criteria) this;
        }

        public Criteria andSinglemaxallowvoltageBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("SingleMaxAllowVoltage between", value1, value2, "singlemaxallowvoltage");
            return (Criteria) this;
        }

        public Criteria andSinglemaxallowvoltageNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("SingleMaxAllowVoltage not between", value1, value2, "singlemaxallowvoltage");
            return (Criteria) this;
        }

        public Criteria andSinglehighvoltageIsNull() {
            addCriterion("SingleHighVoltage is null");
            return (Criteria) this;
        }

        public Criteria andSinglehighvoltageIsNotNull() {
            addCriterion("SingleHighVoltage is not null");
            return (Criteria) this;
        }

        public Criteria andSinglehighvoltageEqualTo(BigDecimal value) {
            addCriterion("SingleHighVoltage =", value, "singlehighvoltage");
            return (Criteria) this;
        }

        public Criteria andSinglehighvoltageNotEqualTo(BigDecimal value) {
            addCriterion("SingleHighVoltage <>", value, "singlehighvoltage");
            return (Criteria) this;
        }

        public Criteria andSinglehighvoltageGreaterThan(BigDecimal value) {
            addCriterion("SingleHighVoltage >", value, "singlehighvoltage");
            return (Criteria) this;
        }

        public Criteria andSinglehighvoltageGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("SingleHighVoltage >=", value, "singlehighvoltage");
            return (Criteria) this;
        }

        public Criteria andSinglehighvoltageLessThan(BigDecimal value) {
            addCriterion("SingleHighVoltage <", value, "singlehighvoltage");
            return (Criteria) this;
        }

        public Criteria andSinglehighvoltageLessThanOrEqualTo(BigDecimal value) {
            addCriterion("SingleHighVoltage <=", value, "singlehighvoltage");
            return (Criteria) this;
        }

        public Criteria andSinglehighvoltageIn(List<BigDecimal> values) {
            addCriterion("SingleHighVoltage in", values, "singlehighvoltage");
            return (Criteria) this;
        }

        public Criteria andSinglehighvoltageNotIn(List<BigDecimal> values) {
            addCriterion("SingleHighVoltage not in", values, "singlehighvoltage");
            return (Criteria) this;
        }

        public Criteria andSinglehighvoltageBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("SingleHighVoltage between", value1, value2, "singlehighvoltage");
            return (Criteria) this;
        }

        public Criteria andSinglehighvoltageNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("SingleHighVoltage not between", value1, value2, "singlehighvoltage");
            return (Criteria) this;
        }

        public Criteria andSinglelowvoltageIsNull() {
            addCriterion("SingleLowVoltage is null");
            return (Criteria) this;
        }

        public Criteria andSinglelowvoltageIsNotNull() {
            addCriterion("SingleLowVoltage is not null");
            return (Criteria) this;
        }

        public Criteria andSinglelowvoltageEqualTo(BigDecimal value) {
            addCriterion("SingleLowVoltage =", value, "singlelowvoltage");
            return (Criteria) this;
        }

        public Criteria andSinglelowvoltageNotEqualTo(BigDecimal value) {
            addCriterion("SingleLowVoltage <>", value, "singlelowvoltage");
            return (Criteria) this;
        }

        public Criteria andSinglelowvoltageGreaterThan(BigDecimal value) {
            addCriterion("SingleLowVoltage >", value, "singlelowvoltage");
            return (Criteria) this;
        }

        public Criteria andSinglelowvoltageGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("SingleLowVoltage >=", value, "singlelowvoltage");
            return (Criteria) this;
        }

        public Criteria andSinglelowvoltageLessThan(BigDecimal value) {
            addCriterion("SingleLowVoltage <", value, "singlelowvoltage");
            return (Criteria) this;
        }

        public Criteria andSinglelowvoltageLessThanOrEqualTo(BigDecimal value) {
            addCriterion("SingleLowVoltage <=", value, "singlelowvoltage");
            return (Criteria) this;
        }

        public Criteria andSinglelowvoltageIn(List<BigDecimal> values) {
            addCriterion("SingleLowVoltage in", values, "singlelowvoltage");
            return (Criteria) this;
        }

        public Criteria andSinglelowvoltageNotIn(List<BigDecimal> values) {
            addCriterion("SingleLowVoltage not in", values, "singlelowvoltage");
            return (Criteria) this;
        }

        public Criteria andSinglelowvoltageBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("SingleLowVoltage between", value1, value2, "singlelowvoltage");
            return (Criteria) this;
        }

        public Criteria andSinglelowvoltageNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("SingleLowVoltage not between", value1, value2, "singlelowvoltage");
            return (Criteria) this;
        }

        public Criteria andSinglehightempIsNull() {
            addCriterion("SingleHighTemp is null");
            return (Criteria) this;
        }

        public Criteria andSinglehightempIsNotNull() {
            addCriterion("SingleHighTemp is not null");
            return (Criteria) this;
        }

        public Criteria andSinglehightempEqualTo(BigDecimal value) {
            addCriterion("SingleHighTemp =", value, "singlehightemp");
            return (Criteria) this;
        }

        public Criteria andSinglehightempNotEqualTo(BigDecimal value) {
            addCriterion("SingleHighTemp <>", value, "singlehightemp");
            return (Criteria) this;
        }

        public Criteria andSinglehightempGreaterThan(BigDecimal value) {
            addCriterion("SingleHighTemp >", value, "singlehightemp");
            return (Criteria) this;
        }

        public Criteria andSinglehightempGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("SingleHighTemp >=", value, "singlehightemp");
            return (Criteria) this;
        }

        public Criteria andSinglehightempLessThan(BigDecimal value) {
            addCriterion("SingleHighTemp <", value, "singlehightemp");
            return (Criteria) this;
        }

        public Criteria andSinglehightempLessThanOrEqualTo(BigDecimal value) {
            addCriterion("SingleHighTemp <=", value, "singlehightemp");
            return (Criteria) this;
        }

        public Criteria andSinglehightempIn(List<BigDecimal> values) {
            addCriterion("SingleHighTemp in", values, "singlehightemp");
            return (Criteria) this;
        }

        public Criteria andSinglehightempNotIn(List<BigDecimal> values) {
            addCriterion("SingleHighTemp not in", values, "singlehightemp");
            return (Criteria) this;
        }

        public Criteria andSinglehightempBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("SingleHighTemp between", value1, value2, "singlehightemp");
            return (Criteria) this;
        }

        public Criteria andSinglehightempNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("SingleHighTemp not between", value1, value2, "singlehightemp");
            return (Criteria) this;
        }

        public Criteria andSinglelowtempIsNull() {
            addCriterion("SingleLowTemp is null");
            return (Criteria) this;
        }

        public Criteria andSinglelowtempIsNotNull() {
            addCriterion("SingleLowTemp is not null");
            return (Criteria) this;
        }

        public Criteria andSinglelowtempEqualTo(BigDecimal value) {
            addCriterion("SingleLowTemp =", value, "singlelowtemp");
            return (Criteria) this;
        }

        public Criteria andSinglelowtempNotEqualTo(BigDecimal value) {
            addCriterion("SingleLowTemp <>", value, "singlelowtemp");
            return (Criteria) this;
        }

        public Criteria andSinglelowtempGreaterThan(BigDecimal value) {
            addCriterion("SingleLowTemp >", value, "singlelowtemp");
            return (Criteria) this;
        }

        public Criteria andSinglelowtempGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("SingleLowTemp >=", value, "singlelowtemp");
            return (Criteria) this;
        }

        public Criteria andSinglelowtempLessThan(BigDecimal value) {
            addCriterion("SingleLowTemp <", value, "singlelowtemp");
            return (Criteria) this;
        }

        public Criteria andSinglelowtempLessThanOrEqualTo(BigDecimal value) {
            addCriterion("SingleLowTemp <=", value, "singlelowtemp");
            return (Criteria) this;
        }

        public Criteria andSinglelowtempIn(List<BigDecimal> values) {
            addCriterion("SingleLowTemp in", values, "singlelowtemp");
            return (Criteria) this;
        }

        public Criteria andSinglelowtempNotIn(List<BigDecimal> values) {
            addCriterion("SingleLowTemp not in", values, "singlelowtemp");
            return (Criteria) this;
        }

        public Criteria andSinglelowtempBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("SingleLowTemp between", value1, value2, "singlelowtemp");
            return (Criteria) this;
        }

        public Criteria andSinglelowtempNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("SingleLowTemp not between", value1, value2, "singlelowtemp");
            return (Criteria) this;
        }

        public Criteria andBmsversionIsNull() {
            addCriterion("BMSVersion is null");
            return (Criteria) this;
        }

        public Criteria andBmsversionIsNotNull() {
            addCriterion("BMSVersion is not null");
            return (Criteria) this;
        }

        public Criteria andBmsversionEqualTo(String value) {
            addCriterion("BMSVersion =", value, "bmsversion");
            return (Criteria) this;
        }

        public Criteria andBmsversionNotEqualTo(String value) {
            addCriterion("BMSVersion <>", value, "bmsversion");
            return (Criteria) this;
        }

        public Criteria andBmsversionGreaterThan(String value) {
            addCriterion("BMSVersion >", value, "bmsversion");
            return (Criteria) this;
        }

        public Criteria andBmsversionGreaterThanOrEqualTo(String value) {
            addCriterion("BMSVersion >=", value, "bmsversion");
            return (Criteria) this;
        }

        public Criteria andBmsversionLessThan(String value) {
            addCriterion("BMSVersion <", value, "bmsversion");
            return (Criteria) this;
        }

        public Criteria andBmsversionLessThanOrEqualTo(String value) {
            addCriterion("BMSVersion <=", value, "bmsversion");
            return (Criteria) this;
        }

        public Criteria andBmsversionLike(String value) {
            addCriterion("BMSVersion like", value, "bmsversion");
            return (Criteria) this;
        }

        public Criteria andBmsversionNotLike(String value) {
            addCriterion("BMSVersion not like", value, "bmsversion");
            return (Criteria) this;
        }

        public Criteria andBmsversionIn(List<String> values) {
            addCriterion("BMSVersion in", values, "bmsversion");
            return (Criteria) this;
        }

        public Criteria andBmsversionNotIn(List<String> values) {
            addCriterion("BMSVersion not in", values, "bmsversion");
            return (Criteria) this;
        }

        public Criteria andBmsversionBetween(String value1, String value2) {
            addCriterion("BMSVersion between", value1, value2, "bmsversion");
            return (Criteria) this;
        }

        public Criteria andBmsversionNotBetween(String value1, String value2) {
            addCriterion("BMSVersion not between", value1, value2, "bmsversion");
            return (Criteria) this;
        }

        public Criteria andStartpaydateIsNull() {
            addCriterion("StartPayDate is null");
            return (Criteria) this;
        }

        public Criteria andStartpaydateIsNotNull() {
            addCriterion("StartPayDate is not null");
            return (Criteria) this;
        }

        public Criteria andStartpaydateEqualTo(Date value) {
            addCriterion("StartPayDate =", value, "startpaydate");
            return (Criteria) this;
        }

        public Criteria andStartpaydateNotEqualTo(Date value) {
            addCriterion("StartPayDate <>", value, "startpaydate");
            return (Criteria) this;
        }

        public Criteria andStartpaydateGreaterThan(Date value) {
            addCriterion("StartPayDate >", value, "startpaydate");
            return (Criteria) this;
        }

        public Criteria andStartpaydateGreaterThanOrEqualTo(Date value) {
            addCriterion("StartPayDate >=", value, "startpaydate");
            return (Criteria) this;
        }

        public Criteria andStartpaydateLessThan(Date value) {
            addCriterion("StartPayDate <", value, "startpaydate");
            return (Criteria) this;
        }

        public Criteria andStartpaydateLessThanOrEqualTo(Date value) {
            addCriterion("StartPayDate <=", value, "startpaydate");
            return (Criteria) this;
        }

        public Criteria andStartpaydateIn(List<Date> values) {
            addCriterion("StartPayDate in", values, "startpaydate");
            return (Criteria) this;
        }

        public Criteria andStartpaydateNotIn(List<Date> values) {
            addCriterion("StartPayDate not in", values, "startpaydate");
            return (Criteria) this;
        }

        public Criteria andStartpaydateBetween(Date value1, Date value2) {
            addCriterion("StartPayDate between", value1, value2, "startpaydate");
            return (Criteria) this;
        }

        public Criteria andStartpaydateNotBetween(Date value1, Date value2) {
            addCriterion("StartPayDate not between", value1, value2, "startpaydate");
            return (Criteria) this;
        }

        public Criteria andFinishedpaydateIsNull() {
            addCriterion("FinishedPayDate is null");
            return (Criteria) this;
        }

        public Criteria andFinishedpaydateIsNotNull() {
            addCriterion("FinishedPayDate is not null");
            return (Criteria) this;
        }

        public Criteria andFinishedpaydateEqualTo(Date value) {
            addCriterion("FinishedPayDate =", value, "finishedpaydate");
            return (Criteria) this;
        }

        public Criteria andFinishedpaydateNotEqualTo(Date value) {
            addCriterion("FinishedPayDate <>", value, "finishedpaydate");
            return (Criteria) this;
        }

        public Criteria andFinishedpaydateGreaterThan(Date value) {
            addCriterion("FinishedPayDate >", value, "finishedpaydate");
            return (Criteria) this;
        }

        public Criteria andFinishedpaydateGreaterThanOrEqualTo(Date value) {
            addCriterion("FinishedPayDate >=", value, "finishedpaydate");
            return (Criteria) this;
        }

        public Criteria andFinishedpaydateLessThan(Date value) {
            addCriterion("FinishedPayDate <", value, "finishedpaydate");
            return (Criteria) this;
        }

        public Criteria andFinishedpaydateLessThanOrEqualTo(Date value) {
            addCriterion("FinishedPayDate <=", value, "finishedpaydate");
            return (Criteria) this;
        }

        public Criteria andFinishedpaydateIn(List<Date> values) {
            addCriterion("FinishedPayDate in", values, "finishedpaydate");
            return (Criteria) this;
        }

        public Criteria andFinishedpaydateNotIn(List<Date> values) {
            addCriterion("FinishedPayDate not in", values, "finishedpaydate");
            return (Criteria) this;
        }

        public Criteria andFinishedpaydateBetween(Date value1, Date value2) {
            addCriterion("FinishedPayDate between", value1, value2, "finishedpaydate");
            return (Criteria) this;
        }

        public Criteria andFinishedpaydateNotBetween(Date value1, Date value2) {
            addCriterion("FinishedPayDate not between", value1, value2, "finishedpaydate");
            return (Criteria) this;
        }

        public Criteria andPaystatusIsNull() {
            addCriterion("PayStatus is null");
            return (Criteria) this;
        }

        public Criteria andPaystatusIsNotNull() {
            addCriterion("PayStatus is not null");
            return (Criteria) this;
        }

        public Criteria andPaystatusEqualTo(Integer value) {
            addCriterion("PayStatus =", value, "paystatus");
            return (Criteria) this;
        }

        public Criteria andPaystatusNotEqualTo(Integer value) {
            addCriterion("PayStatus <>", value, "paystatus");
            return (Criteria) this;
        }

        public Criteria andPaystatusGreaterThan(Integer value) {
            addCriterion("PayStatus >", value, "paystatus");
            return (Criteria) this;
        }

        public Criteria andPaystatusGreaterThanOrEqualTo(Integer value) {
            addCriterion("PayStatus >=", value, "paystatus");
            return (Criteria) this;
        }

        public Criteria andPaystatusLessThan(Integer value) {
            addCriterion("PayStatus <", value, "paystatus");
            return (Criteria) this;
        }

        public Criteria andPaystatusLessThanOrEqualTo(Integer value) {
            addCriterion("PayStatus <=", value, "paystatus");
            return (Criteria) this;
        }

        public Criteria andPaystatusIn(List<Integer> values) {
            addCriterion("PayStatus in", values, "paystatus");
            return (Criteria) this;
        }

        public Criteria andPaystatusNotIn(List<Integer> values) {
            addCriterion("PayStatus not in", values, "paystatus");
            return (Criteria) this;
        }

        public Criteria andPaystatusBetween(Integer value1, Integer value2) {
            addCriterion("PayStatus between", value1, value2, "paystatus");
            return (Criteria) this;
        }

        public Criteria andPaystatusNotBetween(Integer value1, Integer value2) {
            addCriterion("PayStatus not between", value1, value2, "paystatus");
            return (Criteria) this;
        }

        public Criteria andViewdatetimeIsNull() {
            addCriterion("ViewDateTime is null");
            return (Criteria) this;
        }

        public Criteria andViewdatetimeIsNotNull() {
            addCriterion("ViewDateTime is not null");
            return (Criteria) this;
        }

        public Criteria andViewdatetimeEqualTo(Date value) {
            addCriterion("ViewDateTime =", value, "viewdatetime");
            return (Criteria) this;
        }

        public Criteria andViewdatetimeNotEqualTo(Date value) {
            addCriterion("ViewDateTime <>", value, "viewdatetime");
            return (Criteria) this;
        }

        public Criteria andViewdatetimeGreaterThan(Date value) {
            addCriterion("ViewDateTime >", value, "viewdatetime");
            return (Criteria) this;
        }

        public Criteria andViewdatetimeGreaterThanOrEqualTo(Date value) {
            addCriterion("ViewDateTime >=", value, "viewdatetime");
            return (Criteria) this;
        }

        public Criteria andViewdatetimeLessThan(Date value) {
            addCriterion("ViewDateTime <", value, "viewdatetime");
            return (Criteria) this;
        }

        public Criteria andViewdatetimeLessThanOrEqualTo(Date value) {
            addCriterion("ViewDateTime <=", value, "viewdatetime");
            return (Criteria) this;
        }

        public Criteria andViewdatetimeIn(List<Date> values) {
            addCriterion("ViewDateTime in", values, "viewdatetime");
            return (Criteria) this;
        }

        public Criteria andViewdatetimeNotIn(List<Date> values) {
            addCriterion("ViewDateTime not in", values, "viewdatetime");
            return (Criteria) this;
        }

        public Criteria andViewdatetimeBetween(Date value1, Date value2) {
            addCriterion("ViewDateTime between", value1, value2, "viewdatetime");
            return (Criteria) this;
        }

        public Criteria andViewdatetimeNotBetween(Date value1, Date value2) {
            addCriterion("ViewDateTime not between", value1, value2, "viewdatetime");
            return (Criteria) this;
        }

        public Criteria andChargestatusIsNull() {
            addCriterion("ChargeStatus is null");
            return (Criteria) this;
        }

        public Criteria andChargestatusIsNotNull() {
            addCriterion("ChargeStatus is not null");
            return (Criteria) this;
        }

        public Criteria andChargestatusEqualTo(Integer value) {
            addCriterion("ChargeStatus =", value, "chargestatus");
            return (Criteria) this;
        }

        public Criteria andChargestatusNotEqualTo(Integer value) {
            addCriterion("ChargeStatus <>", value, "chargestatus");
            return (Criteria) this;
        }

        public Criteria andChargestatusGreaterThan(Integer value) {
            addCriterion("ChargeStatus >", value, "chargestatus");
            return (Criteria) this;
        }

        public Criteria andChargestatusGreaterThanOrEqualTo(Integer value) {
            addCriterion("ChargeStatus >=", value, "chargestatus");
            return (Criteria) this;
        }

        public Criteria andChargestatusLessThan(Integer value) {
            addCriterion("ChargeStatus <", value, "chargestatus");
            return (Criteria) this;
        }

        public Criteria andChargestatusLessThanOrEqualTo(Integer value) {
            addCriterion("ChargeStatus <=", value, "chargestatus");
            return (Criteria) this;
        }

        public Criteria andChargestatusIn(List<Integer> values) {
            addCriterion("ChargeStatus in", values, "chargestatus");
            return (Criteria) this;
        }

        public Criteria andChargestatusNotIn(List<Integer> values) {
            addCriterion("ChargeStatus not in", values, "chargestatus");
            return (Criteria) this;
        }

        public Criteria andChargestatusBetween(Integer value1, Integer value2) {
            addCriterion("ChargeStatus between", value1, value2, "chargestatus");
            return (Criteria) this;
        }

        public Criteria andChargestatusNotBetween(Integer value1, Integer value2) {
            addCriterion("ChargeStatus not between", value1, value2, "chargestatus");
            return (Criteria) this;
        }

        public Criteria andSessiontypeIsNull() {
            addCriterion("SessionType is null");
            return (Criteria) this;
        }

        public Criteria andSessiontypeIsNotNull() {
            addCriterion("SessionType is not null");
            return (Criteria) this;
        }

        public Criteria andSessiontypeEqualTo(Integer value) {
            addCriterion("SessionType =", value, "sessiontype");
            return (Criteria) this;
        }

        public Criteria andSessiontypeNotEqualTo(Integer value) {
            addCriterion("SessionType <>", value, "sessiontype");
            return (Criteria) this;
        }

        public Criteria andSessiontypeGreaterThan(Integer value) {
            addCriterion("SessionType >", value, "sessiontype");
            return (Criteria) this;
        }

        public Criteria andSessiontypeGreaterThanOrEqualTo(Integer value) {
            addCriterion("SessionType >=", value, "sessiontype");
            return (Criteria) this;
        }

        public Criteria andSessiontypeLessThan(Integer value) {
            addCriterion("SessionType <", value, "sessiontype");
            return (Criteria) this;
        }

        public Criteria andSessiontypeLessThanOrEqualTo(Integer value) {
            addCriterion("SessionType <=", value, "sessiontype");
            return (Criteria) this;
        }

        public Criteria andSessiontypeIn(List<Integer> values) {
            addCriterion("SessionType in", values, "sessiontype");
            return (Criteria) this;
        }

        public Criteria andSessiontypeNotIn(List<Integer> values) {
            addCriterion("SessionType not in", values, "sessiontype");
            return (Criteria) this;
        }

        public Criteria andSessiontypeBetween(Integer value1, Integer value2) {
            addCriterion("SessionType between", value1, value2, "sessiontype");
            return (Criteria) this;
        }

        public Criteria andSessiontypeNotBetween(Integer value1, Integer value2) {
            addCriterion("SessionType not between", value1, value2, "sessiontype");
            return (Criteria) this;
        }

        public Criteria andCardnoIsNull() {
            addCriterion("CardNo is null");
            return (Criteria) this;
        }

        public Criteria andCardnoIsNotNull() {
            addCriterion("CardNo is not null");
            return (Criteria) this;
        }

        public Criteria andCardnoEqualTo(String value) {
            addCriterion("CardNo =", value, "cardno");
            return (Criteria) this;
        }

        public Criteria andCardnoNotEqualTo(String value) {
            addCriterion("CardNo <>", value, "cardno");
            return (Criteria) this;
        }

        public Criteria andCardnoGreaterThan(String value) {
            addCriterion("CardNo >", value, "cardno");
            return (Criteria) this;
        }

        public Criteria andCardnoGreaterThanOrEqualTo(String value) {
            addCriterion("CardNo >=", value, "cardno");
            return (Criteria) this;
        }

        public Criteria andCardnoLessThan(String value) {
            addCriterion("CardNo <", value, "cardno");
            return (Criteria) this;
        }

        public Criteria andCardnoLessThanOrEqualTo(String value) {
            addCriterion("CardNo <=", value, "cardno");
            return (Criteria) this;
        }

        public Criteria andCardnoLike(String value) {
            addCriterion("CardNo like", value, "cardno");
            return (Criteria) this;
        }

        public Criteria andCardnoNotLike(String value) {
            addCriterion("CardNo not like", value, "cardno");
            return (Criteria) this;
        }

        public Criteria andCardnoIn(List<String> values) {
            addCriterion("CardNo in", values, "cardno");
            return (Criteria) this;
        }

        public Criteria andCardnoNotIn(List<String> values) {
            addCriterion("CardNo not in", values, "cardno");
            return (Criteria) this;
        }

        public Criteria andCardnoBetween(String value1, String value2) {
            addCriterion("CardNo between", value1, value2, "cardno");
            return (Criteria) this;
        }

        public Criteria andCardnoNotBetween(String value1, String value2) {
            addCriterion("CardNo not between", value1, value2, "cardno");
            return (Criteria) this;
        }

        public Criteria andCreatedateIsNull() {
            addCriterion("CreateDate is null");
            return (Criteria) this;
        }

        public Criteria andCreatedateIsNotNull() {
            addCriterion("CreateDate is not null");
            return (Criteria) this;
        }

        public Criteria andCreatedateEqualTo(Date value) {
            addCriterion("CreateDate =", value, "createdate");
            return (Criteria) this;
        }

        public Criteria andCreatedateNotEqualTo(Date value) {
            addCriterion("CreateDate <>", value, "createdate");
            return (Criteria) this;
        }

        public Criteria andCreatedateGreaterThan(Date value) {
            addCriterion("CreateDate >", value, "createdate");
            return (Criteria) this;
        }

        public Criteria andCreatedateGreaterThanOrEqualTo(Date value) {
            addCriterion("CreateDate >=", value, "createdate");
            return (Criteria) this;
        }

        public Criteria andCreatedateLessThan(Date value) {
            addCriterion("CreateDate <", value, "createdate");
            return (Criteria) this;
        }

        public Criteria andCreatedateLessThanOrEqualTo(Date value) {
            addCriterion("CreateDate <=", value, "createdate");
            return (Criteria) this;
        }

        public Criteria andCreatedateIn(List<Date> values) {
            addCriterion("CreateDate in", values, "createdate");
            return (Criteria) this;
        }

        public Criteria andCreatedateNotIn(List<Date> values) {
            addCriterion("CreateDate not in", values, "createdate");
            return (Criteria) this;
        }

        public Criteria andCreatedateBetween(Date value1, Date value2) {
            addCriterion("CreateDate between", value1, value2, "createdate");
            return (Criteria) this;
        }

        public Criteria andCreatedateNotBetween(Date value1, Date value2) {
            addCriterion("CreateDate not between", value1, value2, "createdate");
            return (Criteria) this;
        }

        public Criteria andDataupdatedateIsNull() {
            addCriterion("DataUpdateDate is null");
            return (Criteria) this;
        }

        public Criteria andDataupdatedateIsNotNull() {
            addCriterion("DataUpdateDate is not null");
            return (Criteria) this;
        }

        public Criteria andDataupdatedateEqualTo(Date value) {
            addCriterion("DataUpdateDate =", value, "dataupdatedate");
            return (Criteria) this;
        }

        public Criteria andDataupdatedateNotEqualTo(Date value) {
            addCriterion("DataUpdateDate <>", value, "dataupdatedate");
            return (Criteria) this;
        }

        public Criteria andDataupdatedateGreaterThan(Date value) {
            addCriterion("DataUpdateDate >", value, "dataupdatedate");
            return (Criteria) this;
        }

        public Criteria andDataupdatedateGreaterThanOrEqualTo(Date value) {
            addCriterion("DataUpdateDate >=", value, "dataupdatedate");
            return (Criteria) this;
        }

        public Criteria andDataupdatedateLessThan(Date value) {
            addCriterion("DataUpdateDate <", value, "dataupdatedate");
            return (Criteria) this;
        }

        public Criteria andDataupdatedateLessThanOrEqualTo(Date value) {
            addCriterion("DataUpdateDate <=", value, "dataupdatedate");
            return (Criteria) this;
        }

        public Criteria andDataupdatedateIn(List<Date> values) {
            addCriterion("DataUpdateDate in", values, "dataupdatedate");
            return (Criteria) this;
        }

        public Criteria andDataupdatedateNotIn(List<Date> values) {
            addCriterion("DataUpdateDate not in", values, "dataupdatedate");
            return (Criteria) this;
        }

        public Criteria andDataupdatedateBetween(Date value1, Date value2) {
            addCriterion("DataUpdateDate between", value1, value2, "dataupdatedate");
            return (Criteria) this;
        }

        public Criteria andDataupdatedateNotBetween(Date value1, Date value2) {
            addCriterion("DataUpdateDate not between", value1, value2, "dataupdatedate");
            return (Criteria) this;
        }

        public Criteria andChargemodeIsNull() {
            addCriterion("ChargeMode is null");
            return (Criteria) this;
        }

        public Criteria andChargemodeIsNotNull() {
            addCriterion("ChargeMode is not null");
            return (Criteria) this;
        }

        public Criteria andChargemodeEqualTo(Integer value) {
            addCriterion("ChargeMode =", value, "chargemode");
            return (Criteria) this;
        }

        public Criteria andChargemodeNotEqualTo(Integer value) {
            addCriterion("ChargeMode <>", value, "chargemode");
            return (Criteria) this;
        }

        public Criteria andChargemodeGreaterThan(Integer value) {
            addCriterion("ChargeMode >", value, "chargemode");
            return (Criteria) this;
        }

        public Criteria andChargemodeGreaterThanOrEqualTo(Integer value) {
            addCriterion("ChargeMode >=", value, "chargemode");
            return (Criteria) this;
        }

        public Criteria andChargemodeLessThan(Integer value) {
            addCriterion("ChargeMode <", value, "chargemode");
            return (Criteria) this;
        }

        public Criteria andChargemodeLessThanOrEqualTo(Integer value) {
            addCriterion("ChargeMode <=", value, "chargemode");
            return (Criteria) this;
        }

        public Criteria andChargemodeIn(List<Integer> values) {
            addCriterion("ChargeMode in", values, "chargemode");
            return (Criteria) this;
        }

        public Criteria andChargemodeNotIn(List<Integer> values) {
            addCriterion("ChargeMode not in", values, "chargemode");
            return (Criteria) this;
        }

        public Criteria andChargemodeBetween(Integer value1, Integer value2) {
            addCriterion("ChargeMode between", value1, value2, "chargemode");
            return (Criteria) this;
        }

        public Criteria andChargemodeNotBetween(Integer value1, Integer value2) {
            addCriterion("ChargeMode not between", value1, value2, "chargemode");
            return (Criteria) this;
        }

        public Criteria andModevalueIsNull() {
            addCriterion("ModeValue is null");
            return (Criteria) this;
        }

        public Criteria andModevalueIsNotNull() {
            addCriterion("ModeValue is not null");
            return (Criteria) this;
        }

        public Criteria andModevalueEqualTo(BigDecimal value) {
            addCriterion("ModeValue =", value, "modevalue");
            return (Criteria) this;
        }

        public Criteria andModevalueNotEqualTo(BigDecimal value) {
            addCriterion("ModeValue <>", value, "modevalue");
            return (Criteria) this;
        }

        public Criteria andModevalueGreaterThan(BigDecimal value) {
            addCriterion("ModeValue >", value, "modevalue");
            return (Criteria) this;
        }

        public Criteria andModevalueGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("ModeValue >=", value, "modevalue");
            return (Criteria) this;
        }

        public Criteria andModevalueLessThan(BigDecimal value) {
            addCriterion("ModeValue <", value, "modevalue");
            return (Criteria) this;
        }

        public Criteria andModevalueLessThanOrEqualTo(BigDecimal value) {
            addCriterion("ModeValue <=", value, "modevalue");
            return (Criteria) this;
        }

        public Criteria andModevalueIn(List<BigDecimal> values) {
            addCriterion("ModeValue in", values, "modevalue");
            return (Criteria) this;
        }

        public Criteria andModevalueNotIn(List<BigDecimal> values) {
            addCriterion("ModeValue not in", values, "modevalue");
            return (Criteria) this;
        }

        public Criteria andModevalueBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("ModeValue between", value1, value2, "modevalue");
            return (Criteria) this;
        }

        public Criteria andModevalueNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("ModeValue not between", value1, value2, "modevalue");
            return (Criteria) this;
        }

        public Criteria andUserstarttimeIsNull() {
            addCriterion("UserStartTime is null");
            return (Criteria) this;
        }

        public Criteria andUserstarttimeIsNotNull() {
            addCriterion("UserStartTime is not null");
            return (Criteria) this;
        }

        public Criteria andUserstarttimeEqualTo(Date value) {
            addCriterion("UserStartTime =", value, "userstarttime");
            return (Criteria) this;
        }

        public Criteria andUserstarttimeNotEqualTo(Date value) {
            addCriterion("UserStartTime <>", value, "userstarttime");
            return (Criteria) this;
        }

        public Criteria andUserstarttimeGreaterThan(Date value) {
            addCriterion("UserStartTime >", value, "userstarttime");
            return (Criteria) this;
        }

        public Criteria andUserstarttimeGreaterThanOrEqualTo(Date value) {
            addCriterion("UserStartTime >=", value, "userstarttime");
            return (Criteria) this;
        }

        public Criteria andUserstarttimeLessThan(Date value) {
            addCriterion("UserStartTime <", value, "userstarttime");
            return (Criteria) this;
        }

        public Criteria andUserstarttimeLessThanOrEqualTo(Date value) {
            addCriterion("UserStartTime <=", value, "userstarttime");
            return (Criteria) this;
        }

        public Criteria andUserstarttimeIn(List<Date> values) {
            addCriterion("UserStartTime in", values, "userstarttime");
            return (Criteria) this;
        }

        public Criteria andUserstarttimeNotIn(List<Date> values) {
            addCriterion("UserStartTime not in", values, "userstarttime");
            return (Criteria) this;
        }

        public Criteria andUserstarttimeBetween(Date value1, Date value2) {
            addCriterion("UserStartTime between", value1, value2, "userstarttime");
            return (Criteria) this;
        }

        public Criteria andUserstarttimeNotBetween(Date value1, Date value2) {
            addCriterion("UserStartTime not between", value1, value2, "userstarttime");
            return (Criteria) this;
        }

        public Criteria andIslockedIsNull() {
            addCriterion("IsLocked is null");
            return (Criteria) this;
        }

        public Criteria andIslockedIsNotNull() {
            addCriterion("IsLocked is not null");
            return (Criteria) this;
        }

        public Criteria andIslockedEqualTo(Boolean value) {
            addCriterion("IsLocked =", value, "islocked");
            return (Criteria) this;
        }

        public Criteria andIslockedNotEqualTo(Boolean value) {
            addCriterion("IsLocked <>", value, "islocked");
            return (Criteria) this;
        }

        public Criteria andIslockedGreaterThan(Boolean value) {
            addCriterion("IsLocked >", value, "islocked");
            return (Criteria) this;
        }

        public Criteria andIslockedGreaterThanOrEqualTo(Boolean value) {
            addCriterion("IsLocked >=", value, "islocked");
            return (Criteria) this;
        }

        public Criteria andIslockedLessThan(Boolean value) {
            addCriterion("IsLocked <", value, "islocked");
            return (Criteria) this;
        }

        public Criteria andIslockedLessThanOrEqualTo(Boolean value) {
            addCriterion("IsLocked <=", value, "islocked");
            return (Criteria) this;
        }

        public Criteria andIslockedIn(List<Boolean> values) {
            addCriterion("IsLocked in", values, "islocked");
            return (Criteria) this;
        }

        public Criteria andIslockedNotIn(List<Boolean> values) {
            addCriterion("IsLocked not in", values, "islocked");
            return (Criteria) this;
        }

        public Criteria andIslockedBetween(Boolean value1, Boolean value2) {
            addCriterion("IsLocked between", value1, value2, "islocked");
            return (Criteria) this;
        }

        public Criteria andIslockedNotBetween(Boolean value1, Boolean value2) {
            addCriterion("IsLocked not between", value1, value2, "islocked");
            return (Criteria) this;
        }

        public Criteria andServicefeeIsNull() {
            addCriterion("ServiceFee is null");
            return (Criteria) this;
        }

        public Criteria andServicefeeIsNotNull() {
            addCriterion("ServiceFee is not null");
            return (Criteria) this;
        }

        public Criteria andServicefeeEqualTo(BigDecimal value) {
            addCriterion("ServiceFee =", value, "servicefee");
            return (Criteria) this;
        }

        public Criteria andServicefeeNotEqualTo(BigDecimal value) {
            addCriterion("ServiceFee <>", value, "servicefee");
            return (Criteria) this;
        }

        public Criteria andServicefeeGreaterThan(BigDecimal value) {
            addCriterion("ServiceFee >", value, "servicefee");
            return (Criteria) this;
        }

        public Criteria andServicefeeGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("ServiceFee >=", value, "servicefee");
            return (Criteria) this;
        }

        public Criteria andServicefeeLessThan(BigDecimal value) {
            addCriterion("ServiceFee <", value, "servicefee");
            return (Criteria) this;
        }

        public Criteria andServicefeeLessThanOrEqualTo(BigDecimal value) {
            addCriterion("ServiceFee <=", value, "servicefee");
            return (Criteria) this;
        }

        public Criteria andServicefeeIn(List<BigDecimal> values) {
            addCriterion("ServiceFee in", values, "servicefee");
            return (Criteria) this;
        }

        public Criteria andServicefeeNotIn(List<BigDecimal> values) {
            addCriterion("ServiceFee not in", values, "servicefee");
            return (Criteria) this;
        }

        public Criteria andServicefeeBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("ServiceFee between", value1, value2, "servicefee");
            return (Criteria) this;
        }

        public Criteria andServicefeeNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("ServiceFee not between", value1, value2, "servicefee");
            return (Criteria) this;
        }
    }

    /**
     */
    public static class Criteria extends GeneratedCriteria {

        protected Criteria() {
            super();
        }
    }

    public static class Criterion {
        private String condition;

        private Object value;

        private Object secondValue;

        private boolean noValue;

        private boolean singleValue;

        private boolean betweenValue;

        private boolean listValue;

        private String typeHandler;

        public String getCondition() {
            return condition;
        }

        public Object getValue() {
            return value;
        }

        public Object getSecondValue() {
            return secondValue;
        }

        public boolean isNoValue() {
            return noValue;
        }

        public boolean isSingleValue() {
            return singleValue;
        }

        public boolean isBetweenValue() {
            return betweenValue;
        }

        public boolean isListValue() {
            return listValue;
        }

        public String getTypeHandler() {
            return typeHandler;
        }

        protected Criterion(String condition) {
            super();
            this.condition = condition;
            this.typeHandler = null;
            this.noValue = true;
        }

        protected Criterion(String condition, Object value, String typeHandler) {
            super();
            this.condition = condition;
            this.value = value;
            this.typeHandler = typeHandler;
            if (value instanceof List<?>) {
                this.listValue = true;
            } else {
                this.singleValue = true;
            }
        }

        protected Criterion(String condition, Object value) {
            this(condition, value, null);
        }

        protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
            super();
            this.condition = condition;
            this.value = value;
            this.secondValue = secondValue;
            this.typeHandler = typeHandler;
            this.betweenValue = true;
        }

        protected Criterion(String condition, Object value, Object secondValue) {
            this(condition, value, secondValue, null);
        }
    }
}